home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-04 / pxewin.zip / PXTBL.CPP < prev    next >
Text File  |  1992-02-06  |  9KB  |  369 lines
  1. // PXEWIN - (C) Copyright 1992 by Beam Engineering, INC.
  2.  
  3. // PXTBL.CPP //
  4.  
  5. // Contents ----------------------------------------------------------------
  6. //
  7. //    This module contains members of the PXTbl class for interfacing with
  8. //    Paradox tables.
  9. //
  10. // End ---------------------------------------------------------------------
  11.  
  12. // External Reference Name for this Header ---------------------------------
  13.  
  14. #ifndef PXTBL_CPP
  15.     #define PXTBL_CPP
  16.  
  17. // End ---------------------------------------------------------------------
  18.  
  19. // Interface Dependencies --------------------------------------------------
  20.  
  21. #ifndef PXTBL_HPP
  22.     #include "pxtbl.hpp"
  23. #endif // PXTBL_HPP //
  24.  
  25. // End ---------------------------------------------------------------------
  26.  
  27. // member Empty of PXTbl //
  28.  
  29. inline int PXTbl::Empty(Pchar name)
  30. {
  31.     if((EngDataPtr->Errors.pxerr = PXTblEmpty(name)) != PXSUCCESS)
  32.         PXError(ENG_ERROR);
  33.     return EngDataPtr->Errors.pxerr;
  34. }
  35.  
  36. // Summary -----------------------------------------------------------------
  37. //
  38. //    Removes all records from a table.
  39. //
  40. // Parameter
  41. //
  42. //    name.  Is the name of the table.
  43. //
  44. // Return Value
  45. //
  46. //    pxerr.  Is the PDOX error code.
  47. //
  48. // End ---------------------------------------------------------------------
  49.  
  50. // member Exists fo PXTbl //
  51.  
  52. inline int PXTbl::Exists(void)
  53. {
  54.     if((EngDataPtr->Errors.pxerr = PXTblExist(EngDataPtr->name,&exist))
  55.         != PXSUCCESS)
  56.         PXError(ENG_ERROR);
  57.     return EngDataPtr->Errors.pxerr;
  58. }
  59.  
  60. // Summary -----------------------------------------------------------------
  61. //
  62. //    Check and see if a table is empty or not.
  63. //
  64. // Return Value
  65. //
  66. //     pxerr.  Returns PDOX error status.
  67. //
  68. // End ---------------------------------------------------------------------
  69.  
  70. // constructor PXTbl //
  71.  
  72. inline PXTbl::PXTbl(PPXEngObject my_object)
  73. {
  74.     close_status = CLOSED;
  75.  
  76.     // Point to the engine data structure
  77.  
  78.     EngDataPtr = my_object->EngDataPtr;
  79. }
  80.  
  81. // Summary -----------------------------------------------------------------
  82. //
  83. //    Set the table close status to CLOSED.  Set the Engine Data Pointer to
  84. //    the parent object.
  85. //
  86. // End ---------------------------------------------------------------------
  87.  
  88. // destructor PXTbl //
  89.  
  90. inline PXTbl::~PXTbl(void)
  91. {
  92.     if(close_status == OPENED)
  93.     {
  94.         if((EngDataPtr->Errors.pxerr =
  95.             PXTblClose(EngDataPtr->tblHandle)) != PXSUCCESS)
  96.             PXError(ENG_ERROR);
  97.     }
  98. }
  99.  
  100. // Summary -----------------------------------------------------------------
  101. //
  102. //    If table is opened, close it.
  103. //
  104. // End ---------------------------------------------------------------------
  105.  
  106. // member build of PXTbl //
  107.  
  108. PTStreamable PXTbl::build()
  109. {
  110.     return new PXTbl(streamableInit);
  111. }
  112.  
  113. TStreamableClass RegPXTbl("PXTbl",PXTbl::build,
  114.     __DELTA(PXTbl));
  115.  
  116. // Description -------------------------------------------------------------
  117. //
  118. //    When the streamable constructor is called, TStreamable dispatches
  119. //    the build member to construct the object.  To do this, it must
  120. //    know where to find this member functions for the specific class.
  121. //    This is the reason for the stream registration.
  122. //
  123. // End ---------------------------------------------------------------------
  124.  
  125. // member read of PXTbl //
  126.  
  127. inline Pvoid PXTbl::read(Ripstream)
  128. {
  129.     return this;
  130. }
  131.  
  132. // Description -------------------------------------------------------------
  133. //
  134. //    Nothing taken from the stream.
  135. //
  136. // End ---------------------------------------------------------------------
  137.  
  138. // member write of PXTbl //
  139.  
  140. inline void PXTbl::write(Ropstream)
  141. {
  142.  
  143. }
  144.  
  145. // Description -------------------------------------------------------------
  146. //
  147. //    Nothing put on the stream.
  148. //
  149. // End ---------------------------------------------------------------------
  150.  
  151. // member NumRecs of PXTbl //
  152.  
  153. inline int PXTbl::NumRecs()
  154. {
  155.     if((EngDataPtr->Errors.pxerr = PXTblNRecs(EngDataPtr->tblHandle,
  156.         &EngDataPtr->num_recs)) != PXSUCCESS)
  157.         PXError(ENG_ERROR);
  158.     return EngDataPtr->Errors.pxerr;
  159. }
  160.  
  161. // Summary -----------------------------------------------------------------
  162. //
  163. //    Get the number of records in the table.
  164. //
  165. // Return Value
  166. //
  167. //    pxerr.  Returns PDOX error status.
  168. //
  169. // End ---------------------------------------------------------------------
  170.  
  171. // member NumFlds of PXTbl //
  172.  
  173. inline int PXTbl::NumFlds()
  174. {
  175.     if((EngDataPtr->Errors.pxerr = PXRecNFlds(EngDataPtr->tblHandle,
  176.         &EngDataPtr->num_fields)) != PXSUCCESS)
  177.         PXError(ENG_ERROR);
  178.     return EngDataPtr->Errors.pxerr;
  179. }
  180.  
  181. // Summary -----------------------------------------------------------------
  182. //
  183. //    Get the number of fields in the table.
  184. //
  185. // Return Value
  186. //
  187. //    pxerr.  Returns the number of fields in the database.
  188. //
  189. // End ---------------------------------------------------------------------
  190.  
  191. // member Open of PXtbl //
  192.  
  193. int PXTbl::Open(int index,int mode,int op)
  194. {
  195.  
  196.     // Make a copy of all the parameters
  197.  
  198.     inx = index;
  199.     md = mode;
  200.     operation = op;
  201.  
  202.     // Check and see if table exists.  If not, set error and return.
  203.  
  204.     if(Exists() != PXSUCCESS)
  205.         return EngDataPtr->Errors.pxerr;
  206.  
  207.     // If table does not exist, return
  208.  
  209.     if(!exist)
  210.     {
  211.         EngDataPtr->Errors.pxerr = PXEWERR_TBLNOTEXIST;
  212.         PXError(EWIN_ERROR);
  213.         return EngDataPtr->Errors.pxerr;
  214.     }
  215.  
  216.     // If OVERWRITE, empty table
  217.  
  218.     if(op == OVERWRITE)
  219.     {
  220.         if(Empty(EngDataPtr->name) != PXSUCCESS)
  221.             return EngDataPtr->Errors.pxerr;
  222.     }
  223.  
  224.     // Open the table
  225.  
  226.     if((EngDataPtr->Errors.pxerr = PXTblOpen(EngDataPtr->name,
  227.     &EngDataPtr->tblHandle,inx,md)) != PXSUCCESS)
  228.         PXError(ENG_ERROR);
  229.     else
  230.         close_status = OPENED;
  231.     return EngDataPtr->Errors.pxerr;
  232. }
  233.  
  234. // Summary -----------------------------------------------------------------
  235. //
  236. //    member opens a table with correct index, mode and operation.
  237. //
  238. // Parameters
  239. //
  240. //    name.  This is the name of the table you wish to operate on.  You
  241. //    don't need the file extension but you must spec out your path.
  242. //
  243. //      index.  This is the number cooresponding to the index you wish to use
  244. //    on the table.
  245. //
  246. //    mode.  This parameter specifies whether you wish to save every change
  247. //    to the disk imediately or have it buffered.
  248. //
  249. //    op.  This specifies which operation you wish to perform.  You can
  250. //      open a table in the following predefined modes:
  251. //
  252. //        EXISTS.  Open if table already exists and you wish to work
  253. //        on it.
  254. //
  255. //              OVERWRITE.  If table exists, open it and empty it.
  256. //
  257. // Return Values
  258. //
  259. //      Returns Paradox error code.
  260. //
  261. // Functional Description
  262. //
  263. //    1.  First check to see if table exist.
  264. //
  265. //    2.  If you need to OVERWRITE it, empty it first.
  266. //
  267. //    3.  Open the table.
  268. //
  269. // End ---------------------------------------------------------------------
  270.  
  271. // member Open of PXTbl //
  272.  
  273. int PXTbl::Open(int nfields,PPchar fields,PPchar types,
  274.     int index,int mode)
  275. {
  276.  
  277.     // Initialize parameters
  278.  
  279.     inx = index;
  280.     md = mode;
  281.     operation = CREATE;
  282.  
  283.     // Check to see if table exists first
  284.  
  285.     if(Exists())
  286.         return EngDataPtr->Errors.pxerr;
  287.  
  288.     // If table exists, return
  289.  
  290.     if(exist)
  291.     {
  292.         EngDataPtr->Errors.pxerr = PXEWERR_TBLEXIST;
  293.         {
  294.             PXError(EWIN_ERROR);
  295.             return EngDataPtr->Errors.pxerr;
  296.         }
  297.     }
  298.  
  299.     // Create the table
  300.  
  301.     if((EngDataPtr->Errors.pxerr = PXTblCreate(EngDataPtr->name,nfields,
  302.         fields,types)) != PXSUCCESS)
  303.     {
  304.         PXError(ENG_ERROR);
  305.         return EngDataPtr->Errors.pxerr;
  306.     }
  307.  
  308.     // Open the table
  309.  
  310.     if((EngDataPtr->Errors.pxerr = PXTblOpen(EngDataPtr->name,
  311.         &EngDataPtr->tblHandle,inx,md)) != PXSUCCESS)
  312.         PXError(ENG_ERROR);
  313.     return EngDataPtr->Errors.pxerr;
  314. }
  315.  
  316. // Summary -----------------------------------------------------------------
  317. //
  318. //    This member is used to create a new Paradox table and open it.
  319. //
  320. // Parameters
  321. //
  322. //      name.  Is the name of the table you wish to create.
  323. //
  324. //      nfields.  Is the number of fields in the database.
  325. //
  326. //      fields.  Is the name of each field.
  327. //
  328. //    type. Is the type of each field.
  329. //
  330. //      index.  Type of index you wish to use.
  331. //
  332. //    mode.  Mode you wish to open table with.
  333. //
  334. // Return Value
  335. //
  336. //    This member returns the pxerr code.
  337. //
  338. // Functional Descrition ---------------------------------------------------
  339. //
  340. //    Copy parameters.  Check to see if the database exists first.  If it
  341. //    does, exit.  If it does not, create the table and open the table
  342. //    using the parameters.
  343. //
  344. // End ---------------------------------------------------------------------
  345.  
  346. // member PXError of PXTbl //
  347.  
  348. void PXTbl::PXError(int org)
  349. {
  350.     // Call base class error handler
  351.  
  352.     PXEngObject::PXError(org);
  353.  
  354.     // Pass the error off to the parent:
  355.  
  356.     EngDataPtr->PXEObjPtr->EngDataPtr->Errors.pxerr =
  357.         EngDataPtr->Errors.pxerr;
  358.     EngDataPtr->PXEObjPtr->PXError(EngDataPtr->Errors.Origin);
  359. }
  360.  
  361. // Summary -----------------------------------------------------------------
  362. //
  363. //    This member handles incomming error messages.  The error is passed
  364. //    to the parent object for dispatching it elsewhere.  This creates a
  365. //    centralize error interface.
  366. //
  367. // End ---------------------------------------------------------------------
  368.  
  369. #endif // PXTBL_CPP //